#include "RTClib.h"
#include <LiquidCrystal.h>

RTC_DS1307 Clock;
char daysOfTheWeek[7][12] = {"Sunday", "Monday", "Tuesday", "Wednesday", "Thursday", "Friday", "Saturday"};

const int rs = 12, en = 11, d4 = 5, d5 = 4, d6 = 3, d7 = 2;
LiquidCrystal lcd(rs, en, d4, d5, d6, d7);

int water = 6;
int intevals = 0;
int button_1 = 9;
int button_2 = 10;
int enter = 8;
uint16_t* duration;

//char daysOfTheWeek[7][12] = {"Sunday", "Monday", "Tuesday", "Wednesday", "Thursday", "Friday", "Saturday"};

class Time
{
  public:
    uint16_t Hour_start;
    uint16_t Minute_start;
    uint16_t Hour_stop;
    uint16_t Minute_stop;
    uint16_t Second_start;
    uint16_t Second_stop;
  public:
    Time();
    Time(uint16_t& Hour_s, uint16_t& Minute_s, uint16_t& Second_s, uint16_t& Hour_st, uint16_t& Minute_st, uint16_t& Second_st);
    void set_hour_start(  uint16_t num);
    void set_minute_start(  uint16_t num);
    void set_hour_stop(  uint16_t num);
    void set_minute_stop(  uint16_t num);
    void increase_hour_start ();
    void increase_hour_stop ();
    void increase_minute_start ();
    void increase_minute_stop ();
    void decrease_hour_start ();
    void decrease_hour_stop ();
    void decrease_minute_start ();
    void decrease_minute_stop ();
    uint16_t get_hour_start();
    uint16_t get_minute_start();
    uint16_t get_hour_stop();
    uint16_t get_minute_stop();
    uint16_t get_second_start();
    uint16_t get_second_stop();
};
Time :: Time ()
{
  Hour_start = 0;
  Minute_start = 0;
  Hour_stop = 0;
  Minute_stop = 0;
}
Time :: Time(uint16_t& Hour_s, uint16_t& Minute_s, uint16_t& Second_s, uint16_t& Hour_st, uint16_t& Minute_st,  uint16_t& Second_st)
{
  Hour_start = Hour_s;
  Minute_start = Minute_s;
  Second_start = Second_s;
  Hour_stop = Hour_st;
  Minute_stop = Minute_st;
  Second_stop = Second_st;
}
void Time :: set_hour_start(  uint16_t num)
{
  this->Hour_start = num;
}
void Time:: set_minute_start(  uint16_t num)
{
  this->Minute_start  = num;
}
void Time :: set_hour_stop(  uint16_t num)
{
  this->Hour_stop = num;
}
void Time:: set_minute_stop(  uint16_t num)
{
  this-> Minute_stop = num;
}
uint16_t Time:: get_hour_start()
{
  return   this->Hour_start;
}
uint16_t Time:: get_hour_stop()
{
  return   this->Hour_stop;
}
uint16_t Time:: get_second_start()
{
  return   this->Second_start;
}
uint16_t Time:: get_second_stop()
{
  return   this->Second_stop;
}
uint16_t Time:: get_minute_start()
{
  return this->Minute_start;
}
uint16_t Time:: get_minute_stop()
{
  return   this->Minute_stop;
}
void Time:: increase_hour_start ()
{
  if ( this-> Hour_start == 24 )
  {
    this->Hour_start -= 23;
  }
  else
  {
    this->Hour_start ++;
  }
  lcd.clear();
}
void Time:: increase_hour_stop ()
{
  if ( this-> Hour_stop == 24 )
  {
    uint16_t temp = 0;
    this->Hour_stop = temp;
  }
  else
  {
    this->Hour_stop ++;
  }
  lcd.clear();
}
void Time:: increase_minute_start ()
{
  if ( this-> Minute_start == 59 )
  {
    uint16_t temp = 0;
    this->Minute_start = temp;
  }
  else
  {
    this->Minute_start ++;
  }
  lcd.clear();
}
void Time:: increase_minute_stop ()
{
  if ( this-> Minute_stop == 59 )
  {
    this->Minute_stop -= 58;
  }
  else
  {
    this->Minute_stop ++;
  }
  lcd.clear();
}

void Time:: decrease_hour_start ()
{
  if ( this-> Hour_start == 0 )
  {
    this->Hour_start += 24;
  }
  else
  {
    this->Hour_start --;
  }
  lcd.clear();
}
void Time:: decrease_hour_stop ()
{
  if ( this-> Hour_stop == 0 )
  {
    uint16_t temp = 24;
    this->Hour_stop = temp;
  }
  else
  {
    this->Hour_stop --;
  }
  lcd.clear();
}
void Time:: decrease_minute_start ()
{
  if ( this-> Minute_start == 0 )
  {
    uint16_t temp = 59;
    this->Minute_start = temp;
  }
  else
  {
    this->Minute_start --;
  }
  lcd.clear();
}
void Time:: decrease_minute_stop ()
{
  if ( this-> Minute_stop == 0 )
  {
    this->Minute_stop += 59;
  }
  else
  {
    this->Minute_stop --;
  }
  lcd.clear();
}

Time* arr;

bool check ( const uint16_t& Hour_now, const uint16_t& Minute_now , Time& arr)
{
  Serial.print("now: ");
  Serial.print(Hour_now);
  Serial.print(" : ");
  Serial.println(Minute_now);
  Serial.print("start: ");
  Serial.print(arr.get_hour_start());
  Serial.print(" : ");
  Serial.println(arr.get_minute_start());
  Serial.print("stop: ");
  Serial.print(arr.get_hour_stop());
  Serial.print(" : ");
  Serial.println(arr.get_minute_stop());
  if ( ! ( (Hour_now >= arr.get_hour_stop()) && (Minute_now >= arr.get_minute_stop()) ) == true)
  {
   //Serial.println("check 1 true");
    if ( (( (Hour_now >= arr.get_hour_start()) == true) && ((Minute_now >= arr.get_minute_start() )== true) ) == true)
    {
     // Serial.println("return true");
      return true;
    }
  }
  //Serial.println("return false");
  return false;
}

void Register(int& intevals,  Time* &Time_array)
{

  for ( ;;)
  {
    lcd.setCursor(0, 0);
    lcd.print("intevals: ");
    lcd.print(intevals);
    if (  digitalRead(button_1) == HIGH )
    {
      intevals ++;
      delay(300);
    }
    if (digitalRead(button_2) == HIGH )
    {
      intevals --;
      delay(300);
    }
    if ( digitalRead(enter) == HIGH)
    {
      break;
    }
  }

  Time_array = new Time[intevals];
  duration = new uint16_t [intevals];

  for ( int i = 0; i < intevals; i++)
  {
    duration[i] = 0;
  }
  for ( int i = 0; i < intevals; i++)
  {
    delay(500);
    lcd.clear();
    for ( ;;)
    {
      lcd.setCursor(0, 0);
      lcd.print("start-");
      lcd.print(i + 1);
      lcd.print(" :");
      lcd.print(Time_array[i]. get_hour_start() );
      lcd.print(" : ");
      lcd.print(Time_array[i]. get_minute_start() );
      if ( digitalRead(button_1) == HIGH)
      {
        Time_array[i].increase_hour_start ();
        delay(200);
      }
      if ( digitalRead(button_2) == HIGH)
      {
        Time_array[i].increase_minute_start ();
        delay(200);
      }
      if ( ( digitalRead(enter) == HIGH) )
      {
        delay(200);
        lcd.clear();
        break;
      }
    }

    for ( ;;)
    {
      lcd.setCursor(0, 0);
      lcd.print("start-");
      lcd.print(i + 1);
      lcd.print(" :");
      lcd.print(Time_array[i]. get_hour_start() );
      lcd.print(" : ");
      lcd.print(Time_array[i]. get_minute_start() );
      lcd.setCursor(0, 1);
      lcd.print("duration: ");
      lcd.print(duration[i]);

      if ( digitalRead(button_1) == HIGH)
      {
        duration[i] ++;
        lcd.clear();
        delay(200);
      }
      if ( digitalRead(button_2) == HIGH)
      {
        duration[i] --;
        lcd.clear();
        delay(200);
      }
      if ( ( digitalRead(enter) == HIGH) )
      {
        delay(200);
        break;
      }
    }
    Time_array[i].Hour_stop = Time_array[i].Hour_start;
    Time_array[i].Minute_stop = Time_array[i].Minute_start + duration[i];
    while (Time_array[i].Minute_stop > 59)
    {
      Time_array[i].increase_hour_stop ();
      Time_array[i].Minute_stop -= 60;
    }
  }
}

Time* Time_array ;

void setup () {
  Serial.begin(9600);
  Serial.println("begin");
  pinMode(water, OUTPUT);
#ifndef ESP8266
  while (!Serial); // wait for serial port to connect. Needed for native USB
#endif
  if (! Clock.begin()) {
    Serial.println("Couldn't find RTC");
    Serial.flush();
    abort();
  }
  lcd.begin(16, 2);
  pinMode(button_1, INPUT);
  pinMode(button_2, INPUT);
  pinMode(enter, INPUT);
  Register(intevals, Time_array);
  if (! Clock.isrunning()) {
    Serial.println("RTC is NOT running, let's set the time!");
    // When time needs to be set on a new device, or after a power loss, the
    // following line sets the RTC to the date & time this sketch was compiled
    Clock.adjust(DateTime(F(__DATE__), F(__TIME__)));
    // This line sets the RTC with an explicit date & time, for example to set
    // January 21, 2014 at 3am you would call:
    // rtc.adjust(DateTime(2014, 1, 21, 3, 0, 0));
  }
  lcd.clear();
}
void loop()
{
  bool flag = false;
  DateTime now = Clock.now();
  for ( int i = 0; i < intevals; i++)
  {
    if (check(now.hour() , now.minute(), Time_array[i]) == true)
    {
      //Serial.println("true");
      digitalWrite(water, HIGH);
      flag = true;
    }
  }
  if ( flag == false )
  {
    digitalWrite(water, LOW);
    //Serial.println("false");
  }
}